package com.qtt.app.service.impl;

import com.qtt.app.entity.*;
import com.qtt.app.entity.ReturnInfo.ReturnConcern;
import com.qtt.app.mapper.*;
import com.qtt.app.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class AppConcernServiceImpl implements AppConcernService {
    @Autowired
    AppConcernMapper appConcernMapper;
    @Autowired
    AppInstitutionMapper appInstitutionMapper;
    @Autowired
    TeachersMapper teachersMapper;
    @Autowired
    GeneralCourseMapper generalCourseMapper;
    @Autowired
    UserMapper userMapper;

    @Override
    public List<ReturnConcern> getMyConcern(Long userId, Integer concernState, Integer flag) {
        //通过userId,concernState,flag查看用户本人关注的机构或老师或课程的所有记录
        List<AppConcern> appConcernEntities = appConcernMapper.getMyConcern(userId, concernState, flag);
        List<ReturnConcern> returnConcernsEntities = new ArrayList<ReturnConcern>();
//        System.out.println(appConcernEntities.size());
        if (appConcernEntities.size() == 0) {
            return returnConcernsEntities;
        }

        //遍历获取到关注表中符合条件的数据，即用户关注的机构列表，但查到的仅有id，还需要借此id去机构表里查找相应字段
        for (int i = 0; i < appConcernEntities.size(); i++) {
            AppConcern appConcernEntity = appConcernEntities.get(i);
            ReturnConcern returnConcernsEntity = new ReturnConcern();
            returnConcernsEntity.setConcernListId(appConcernEntity.getId());//列表自增id
            returnConcernsEntity.setConcernId(appConcernEntity.getConcernId());//关注的机构id，为string
            returnConcernsEntity.setConcernState(concernState);//是否关注，实际不用从关注表获取，参数中就有了
            if (flag == 1) {
                //因为关注表为了方便，存的关注id都为string，实际以flag区分出是机构时，需将id转换成int型
                Integer institutionId = Integer.valueOf(appConcernEntity.getConcernId());
                AppInstitution appInstitutionEntity = appInstitutionMapper.getInstitutionById(institutionId);
                returnConcernsEntity.setPicture(appInstitutionEntity.getLogoPicture());
                returnConcernsEntity.setName(appInstitutionEntity.getInstitutionName());
            }
            if (flag == 2) {
                //获取到的concernId实际上是teacherId，需将id转换成int型.并以主键查找从老师表拿取相关字段
                Integer teacherId = Integer.valueOf(appConcernEntity.getConcernId());
                Teachers teacherEntity = teachersMapper.selectByPrimaryKey(teacherId);
                returnConcernsEntity.setPicture(teacherEntity.getHead());
                returnConcernsEntity.setName(teacherEntity.getRealName());
                returnConcernsEntity.setTeacherRank(teacherEntity.getRanks());
            }
            if (flag == 3) {
                //获取到的concernId实际上是generalId也就是课程id，需将id转换成int型.并以主键查找从general course表拿取相关字段
                String generalId = appConcernEntity.getConcernId();
                GeneralCourse generalCourseEntity = generalCourseMapper.selectByPrimaryKey(generalId);
                returnConcernsEntity.setPicture(generalCourseEntity.getMainPicture());
                returnConcernsEntity.setName(generalCourseEntity.getTitle());

                //授课老师还要用在课程表中获取到的teacherId作为外键去老师表搜
                Teachers teacherEntity = teachersMapper.selectByPrimaryKey(generalCourseEntity.getTeacherId());
                returnConcernsEntity.setCourseTeacher(teacherEntity.getRealName());
                returnConcernsEntity.setTeacherRank(teacherEntity.getRanks());
            }

            //将该实体加到列表中
            returnConcernsEntities.add(returnConcernsEntity);
        }

        return returnConcernsEntities;
    }

    @Override
    public int isConcernInstitution(Long userId, Integer institutionId, Integer concernState, Integer flag) {
        //首先以concernState判断，如果concernState为1，说明要关注机构

        //首先去机构表中进行主键查询，判断该机构id是否存在，不存在则关注失败；
        AppInstitution appInstitutionEntity = appInstitutionMapper.selectByPrimaryKey(institutionId);
        if(appInstitutionEntity ==null){return 402;}//表示传入的机构id有问题
        //首先去用户表中进行主键查询，判断该用户id是否存在，不存在则关注失败；
        User userEntity = userMapper.getById(userId);
        if(userEntity ==null){return 401;}//表示传入的用户id有问题
        //参数确定无误，则从关注表查询是否存在过记录
        String concernId = String.valueOf(institutionId);//concernId为int，concernId为string所以需要转换。
        AppConcern appConcern = appConcernMapper.getConcernInstByFlagAndUserid(flag, userId, concernId);
        System.out.println(appConcern);
        //关注状态为1，表示要关注该机构
        if (concernState == 1) {
            System.out.println("关注的情况一，需要新建");
            //关注有两种情况，一是表中不存在该用户id，则新建一条关注记录，直接将所有参数插入即可。 二是用户已经关注了该机构，只需要找到并修改该记录。
            if (appConcern == null) {//1，以flag userId concernId结合查询，如果不存在记录，说明用户未曾关注该机构
                System.out.println("进到了=null的判断里");
                AppConcern appConcernEntity =new AppConcern();
                appConcernEntity.setUserId(userId);
                appConcernEntity.setConcernState(1);
                appConcernEntity.setFlag(flag);
                appConcernEntity.setConcernId(concernId);
                System.out.println(appConcernEntity);
                int insertResultFlag = appConcernMapper.insert(appConcernEntity);//插入估计要重新写
//                int insertResultFlag = appConcernMapper.addConcernInstitution(appConcernEntity);//插入估计要重新写
                if (insertResultFlag != 0) {
                    return 201;
                } //表示成功关注
            } else {//2，查询结果不为空，说明存在记录，即用户已经关注了该机构但是后来取消了，只需要找到并修改即可
                appConcern.setConcernState(1);//因为存在该记录，但关注状态是未关注，所以需要修改为关注
                int updateResultFlag = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag != 0) {
                    return 201;
                }//表示成功关注
            }
        }//关注的情况结束

        //如果concernState为2，说明要取消关注机构
        else if(concernState ==2) {
            //取消关注只有一种情况，用户已经关注了该机构，即表中存在该记录，只需要找到并修改该记录。
            if (appConcern == null) {//没找到该记录，说明出错了
                return 403;
            } else {
                appConcern.setConcernState(2);
                int updateResultFlag2 = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag2 != 0) {
                    return 202;
                }//表示取消关注
            }
        }
        return 400;//操作失败


    }

    @Override
    public int isConcernTeacher(Long userId, Integer teacherId, Integer concernState, int flag) {
        //首先去老师表中进行主键查询，判断该老师id是否存在，不存在则关注失败；
        Teachers teachersEntity = teachersMapper.selectByPrimaryKey(teacherId);
        if(teachersEntity ==null){return 401;}//表示传入的老师id有问题
        //首先去用户表中进行主键查询，判断该用户id是否存在，不存在则关注失败；
        User userEntity = userMapper.getById(userId);
        if(userEntity ==null){return 402;}//表示传入的用户id有问题
        //参数确定无误，则从关注表查询是否存在过记录
        //首先以concernState判断，如果concernState为1，说明要关注老师
        String concernId = String.valueOf(teacherId);//teacherId为int，concernId为string所以需要转换
        AppConcern appConcern = appConcernMapper.getConcernInstByFlagAndUserid(flag, userId, concernId);
        System.out.println(appConcern);
        //关注状态为1，表示要关注该老师
        if (concernState == 1) {
            System.out.println("关注的情况一，需要新建");
            //关注有两种情况，一是表中不存在该用户id，则新建一条关注记录，直接将所有参数插入即可。 二是用户已经关注了该机构，只需要找到并修改该记录。
            if (appConcern == null) {//1，以flag userId concernId结合查询，如果不存在记录，说明用户未曾关注该机构
                System.out.println("进到了=null的判断里");
                AppConcern appConcernEntity =new AppConcern();
                appConcernEntity.setUserId(userId);
                appConcernEntity.setConcernState(1);
                appConcernEntity.setFlag(flag);
                appConcernEntity.setConcernId(concernId);
                System.out.println(appConcernEntity);
                int insertResultFlag = appConcernMapper.insert(appConcernEntity);//插入估计要重新写
//                int insertResultFlag = appConcernMapper.addConcernInstitution(appConcernEntity);//插入估计要重新写
                if (insertResultFlag != 0) {
                    return 201;
                } //表示成功关注
            } else {//2，查询结果不为空，说明存在记录，即用户已经关注了该老师但是后来取消了，只需要找到并修改即可
                appConcern.setConcernState(1);//因为存在该记录，但关注状态是未关注，所以需要修改为关注
                int updateResultFlag = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag != 0) {
                    return 201;
                }//表示成功关注
            }
        }//关注的情况结束

        //如果concernState为2，说明要取消关注机构
        else if(concernState ==2) {
            //取消关注只有一种情况，用户已经关注了该机构，即表中存在该记录，只需要找到并修改该记录。
            if (appConcern == null) {//没找到该记录，说明出错了
                return 403;
            } else {
                appConcern.setConcernState(2);
                int updateResultFlag2 = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag2 != 0) {
                    return 202;
                }//表示取消关注
            }
        }
        return 400;//操作失败
    }


    @Override
    public int isConcernCourse(Long userId, String generalCourseId, Integer concernState, int flag) {
        //首先去老师表中进行主键查询，判断该老师id是否存在，不存在则关注失败；
        GeneralCourse generalCourseEntity = generalCourseMapper.selectByPrimaryKey(generalCourseId);
        if(generalCourseEntity ==null){return 401;}//表示传入的老师id有问题
        //首先去用户表中进行主键查询，判断该用户id是否存在，不存在则关注失败；
        User userEntity = userMapper.getById(userId);
        if(userEntity ==null){return 402;}//表示传入的用户id有问题
        //参数确定无误，则从关注表查询是否存在过记录
        //首先以concernState判断，如果concernState为1，说明要关注老师
        String concernId = generalCourseId;//generalId为stirng，concernId为string所以不需要转换
        AppConcern appConcern = appConcernMapper.getConcernInstByFlagAndUserid(flag, userId, concernId);
        System.out.println(appConcern);
        //关注状态为1，表示要关注该老师
        if (concernState == 1) {
            System.out.println("关注的情况一，需要新建");
            //关注有两种情况，一是表中不存在该用户id，则新建一条关注记录，直接将所有参数插入即可。 二是用户已经关注了该机构，只需要找到并修改该记录。
            if (appConcern == null) {//1，以flag userId concernId结合查询，如果不存在记录，说明用户未曾关注该机构
                System.out.println("进到了=null的判断里");
                AppConcern appConcernEntity =new AppConcern();
                appConcernEntity.setUserId(userId);
                appConcernEntity.setConcernState(1);
                appConcernEntity.setFlag(flag);
                appConcernEntity.setConcernId(concernId);
                System.out.println(appConcernEntity);
                int insertResultFlag = appConcernMapper.insert(appConcernEntity);//插入估计要重新写
//                int insertResultFlag = appConcernMapper.addConcernInstitution(appConcernEntity);//插入估计要重新写
                if (insertResultFlag != 0) {
                    return 201;
                } //表示成功关注
            } else {//2，查询结果不为空，说明存在记录，即用户已经关注了该老师但是后来取消了，只需要找到并修改即可
                appConcern.setConcernState(1);//因为存在该记录，但关注状态是未关注，所以需要修改为关注
                int updateResultFlag = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag != 0) {
                    return 201;
                }//表示成功关注
            }
        }//关注的情况结束

        //如果concernState为2，说明要取消关注机构
        else if(concernState ==2) {
            //取消关注只有一种情况，用户已经关注了该机构，即表中存在该记录，只需要找到并修改该记录。
            if (appConcern == null) {//没找到该记录，说明出错了
                return 403;
            } else {
                appConcern.setConcernState(2);
                int updateResultFlag2 = appConcernMapper.updateByPrimaryKey(appConcern);
                if (updateResultFlag2 != 0) {
                    return 202;
                }//表示取消关注
            }
        }
        return 400;//操作失败
    }

    @Override
    public Boolean isMyConcern(Long userId, Integer flag, String concernId) {
        Integer concernState = appConcernMapper.isMyConcern(userId,flag,concernId);
        if(concernState ==null){return false;}//只要为空，统一返回false，并不区分细致的错误
        if(concernState == 1){return true;}
        else{return false;}
    }


}










